package com.young.mylib.db;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.google.gson.internal.UnsafeAllocator;
import com.young.mylib.utils.ConverterUtils;
import com.young.mylib.utils.FastJsonUtils;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Set;

/**
 * Created by Young on 2018/3/29.
 */

public class SqliteUtils extends SQLiteOpenHelper implements SqliteImpl {
    private static final String TAG = "SqliteUtils";
    private static final int DB_VISION = 3;

    public SqliteUtils(Context context, String name) {
        super(context, name, null, DB_VISION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {

    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

    }

    @Override
    public void replace(List<Object> list) {
        SQLiteDatabase db = getWritableDatabase();
        db.beginTransaction();  //手动设置开始事务
        try {
//            db.execSQL("update person set amount=amount-10 where personid=?", new Object[]{1});
//            db.execSQL("update person set amount=amount+10 where personid=?", new Object[]{2});
            //设置事务标志为成功，当结束事务时就会提交事务
            db.setTransactionSuccessful();
            db.setTransactionSuccessful(); //设置事务处理成功，不设置会自动回滚不提交
        } catch (Exception e) {
            Log.i(TAG, e.getMessage());
        } finally {
            db.endTransaction(); //处理完成
        }
    }

    @Override
    public void replace(Object obj) {

    }

    @Override
    public void save(Object obj) {
        //获取类类型
        Class<?> table = obj.getClass();
        //创建对应的表
        createTableIfNotExists(table);
        //具体实现保存数据方法
        save(obj, table, getWritableDatabase());
        //  save(JsonUtils.toJsonObject(obj), table, getReadableDatabase());
    }


    private void save(JSONObject json, Class<?> table, SQLiteDatabase db) {
        ContentValues contentValues = new ContentValues();
        Set<String> keySets = json.keySet();
        for (String s : keySets) {
            String value = "";
            if (json.get(s) != null) {
                value = json.get(s).toString();
            }
            contentValues.put(s, value);
        }
        String tableName = getTableName(table);
        //Log.i(TAG, "tabName: " + tableName);
        db.replace(tableName, null, contentValues);
    }

    /**
     * 保存数据的主要操作
     *
     * @param obj   数据库对象
     * @param table 对象类类型
     * @param db    操作数据库
     */
    private void save(Object obj, Class<?> table, SQLiteDatabase db) {

        //将一个对象中的所有字段添加到该数据集中
        ContentValues contentValues = new ContentValues();
        //通过反射获取一个类中的所有属性
        Field[] declaredFields = table.getFields();
        //遍历所有的属性
        for (Field field : declaredFields) {
            //获取对应的修饰类型
            int modifiers = field.getModifiers();
            //如果不是静态的就插入到数据库
            if (!Modifier.isStatic(modifiers)) {
                //设置一下数据访问权限为最高级别，也就是public
                field.setAccessible(true);
                try {
                    //将每一个字段的信息保存到数据集中

                    if (!field.getName().equals("id"))
                        contentValues.put(field.getName(), field.get(obj) + "");
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }

        //对于一般的数据操作，我们采用通常是insert来插入数据，但是为了防止同一个对象的数据进行刷新，所以采用直接替换掉
        String tableName = getTableName(table);
        // Log.i(TAG, "tabName: " + tableName);
        db.replace(tableName, null, contentValues);
       // Log.i(TAG, "save ok: " + tableName);
    }

    /**
     * 这里是保存统一对象的多个数据，通过获取集合中的对象，来保存所有的数据
     *
     * @param collection
     */
    @Override
    public void saveAll(Collection collection) {
        //如果集合为空直接不需要操作
        if (collection.isEmpty()) {
            return;
        }
        SQLiteDatabase db = getWritableDatabase();
        //获取该集合的一个对象即可，因为一个集合中保存的都是同一个对象
        Object next = collection.iterator().next();
        //然后创建该对象所对应的表
        createTableIfNotExists(next.getClass());
        //这里为了提高效率采用了事务处理方式，对于事务这里不做过多的讲解
        db.beginTransaction();
        for (Object o : collection) {
            save(o);
        }
        //设置事务为成功状态
        db.setTransactionSuccessful();
        //当事务结束，才会一次性执行上面for中的所有save方法，如果该事务没有结束，则for中的save方法一个都不会执行
        db.endTransaction();
    }


    /**
     * 通过表名，查询所有的数据，表名对应于类名
     *
     * @param table 类类型
     * @param <T>   泛型参数，任意类型
     * @return
     */
    @Override
    public <T> List<T> queryAll(Class<T> table) {
        //如果该表不存在数据库中，则不需要进行操作
        createTableIfNotExists(table);

        SQLiteDatabase db = getReadableDatabase();
        //获取表名，因为表名是采用完全包名的形式存储，按照表名规则，不允许有 "." 的存在,所以采用"_"进行替换
        String tableName = getTableName(table);
        //通过表名查询所有的数据
        Cursor cursor = db.query(tableName, null, null, null, null, null, null);
        //通过initList拿到对应的数据
        List<T> result = initList(table, cursor);
        //关闭游标
        cursor.close();
        //返回结果
        return result;
    }

    /**
     * 通过指定的顺序返回所有查询的结果
     *
     * @param table   类类型
     * @param orderBy 指定顺序
     * @param <T>     泛型参数
     * @return
     */
    @Override
    public <T> List<T> queryAll(Class<T> table, String orderBy) {
        //这里所有的操作和上面类似，就不依依介绍了
        if (!isTableExists(table)) {
            return null;
        }
        SQLiteDatabase db = getReadableDatabase();
        String tableName = getTableName(table);
        Cursor cursor = db.query(tableName, null, null, null, null, null, orderBy);
        List<T> result = initList(table, cursor);
        return result;
    }

    /**
     * 通过指定的顺序和查询多少页来查询所有的数据
     *
     * @param table   类类型
     * @param orderBy 指定顺序
     * @param limit   指定的页数
     * @param <T>
     * @return
     */
    @Override
    public <T> List<T> queryAll(Class<T> table, String orderBy, int limit) {
        //如上雷同，不做介绍
        if (!isTableExists(table)) {
            return null;
        }
        SQLiteDatabase db = getReadableDatabase();
        String tableName = getTableName(table);
        Cursor cursor = db.query(tableName, null, null, null, null, null, orderBy, String.valueOf(limit));
        List<T> result = initList(table, cursor);
        return result;
    }

    /**
     * 通过id来查询对应的数据
     *
     * @param table
     * @param id
     * @param <T>
     * @return
     */
    @Override
    public <T> T queryById(Class<T> table, Object id) {
        Field idField = null;
        //获取属性id
        idField = getFieldId(table);
        SQLiteDatabase db = getReadableDatabase();
        String tableName = getTableName(table);
        Cursor cursor = db.query(tableName,
                null,
                (idField == null ? "_id" : idField.getName()) + " = ?", //判断，如果对应的类中存在id，则通过该类中的id查找数据，如果不存在id就采用使用默认的_id来查询数据
                new String[]{String.valueOf(id)}, null, null, null);
        List<T> list = initList(table, cursor);

        if (list.isEmpty()) {
            return null;
        } else {
            return list.get(0);//这里是通过id查询数据，因为id唯一，所以查到的数据最多也就一个，直接返回list.get(0)
        }
    }

    /**
     * TODO 有BUG
     *
     * @param table
     * @param sql
     * @param <T>
     * @return
     */
    @Override
    public <T> List<T> rawQuery(Class<T> table, String sql) {

        try {
            SQLiteDatabase db = getReadableDatabase();
            String tableName = getTableName(table);
            sql = sql.replace("xxx###xxx", tableName);
          //  Log.i(TAG, sql);
            Cursor cursor = db.rawQuery(sql, null);
            List<T> list = initList(table, cursor);
            return list;
        } catch (Exception e) {
            return null;
        }
    }

    public <T> T rawQueryOne(Class<T> table, String sql) {
        try {
            SQLiteDatabase db = getReadableDatabase();
            String tableName = getTableName(table);
            sql = sql.replace("xxx###xxx", tableName);
            Log.i(TAG, sql);
            Cursor cursor = db.rawQuery(sql, null);
            return initEntity(table,cursor);
        } catch (Exception e) {
            return null;
        }
    }

    @Override
    public <T> List<T> queryByKey(Class<T> table, String key, String value) {
        createTableIfNotExists(table);

        Field idField = null;
        //获取属性id
        idField = getFieldId(table,key);
        String select = (idField == null ? key : idField.getName()) + " = ?";
      //  Log.i(TAG, "########SQL:" + select);
        SQLiteDatabase db = getReadableDatabase();
        String tableName = getTableName(table);
        Cursor cursor = db.query(tableName,
                null,
                select, //判断，如果对应的类中存在id，则通过该类中的id查找数据，如果不存在id就采用使用默认的_id来查询数据
                new String[]{String.valueOf(value)}, null, null, null);
        List<T> list = initList(table, cursor);
        return list;
    }



    @Override
    public <T> JSONObject queryOneByKey(Class<T> table, String key, String value) {
        createTableIfNotExists(table);

        Field idField = null;
        //获取属性id
        idField = getFieldId(table);
        SQLiteDatabase db = getReadableDatabase();
        String tableName = getTableName(table);
        Cursor cursor = db.query(tableName,
                null,
                (idField == null ? key : idField.getName()) + " = ?", //判断，如果对应的类中存在id，则通过该类中的id查找数据，如果不存在id就采用使用默认的_id来查询数据
                new String[]{String.valueOf(value)}, null, null, null);
        List<JSONObject> list = getJson(table, cursor);
        if (list == null) return null;
        if (list.size() == 0) return null;
        for (JSONObject o : list) {
            if (o.get(key).toString().equals(value)) {
                return o;
            }
        }
        return null;
    }

    public <T> List<JSONObject> queryToJson(Class<T> table) {
        createTableIfNotExists(table);
        Field idField = null;
        //获取属性id
        idField = getFieldId(table);
        SQLiteDatabase db = getReadableDatabase();
        String tableName = getTableName(table);
        Cursor cursor = db.query(tableName, null, null, null, null, null, null);
        //通过initList拿到对应的数据
        List<JSONObject> result = getJson(table, cursor);
        //关闭游标
        cursor.close();

        return result;

    }

    public <T> List<JSONObject> queryToJson(Class<T> table, String key, String value) {
        createTableIfNotExists(table);
        Field idField = null;
        //获取属性id
        idField = getFieldId(table);
        SQLiteDatabase db = getReadableDatabase();
        String tableName = getTableName(table);
        Cursor cursor = db.query(tableName,
                null,
                (idField == null ? key : idField.getName()) + " = ?", //判断，如果对应的类中存在id，则通过该类中的id查找数据，如果不存在id就采用使用默认的_id来查询数据
                new String[]{String.valueOf(value)}, null, null, null);

        return getJson(table, cursor);

    }

    @Override
    public <T> void updateByKey(Object obj, String key, String value) {
        createTableIfNotExists(obj.getClass());
        if (getQueryCount(obj.getClass(), key, value) == 0) {
            save(obj);
            return;
        }

        /**
         * UPDATE table_name
         SET column1 = value1, column2 = value2...., columnN = valueN
         WHERE [condition];
         */
        try {
            JSONObject jsonObject = FastJsonUtils.toJsonObject(obj);
            Set<String> keys = jsonObject.keySet();

            ContentValues values = new ContentValues();
            for (String s : keys) {
                if (jsonObject.get(s) != null) {
                    if (!jsonObject.get(s).toString().equals("-1")) {
                        String v = jsonObject.get(s).toString();//.replace(".", "_");

                        values.put(s, v);
                    }
                }
            }

            SQLiteDatabase db = getWritableDatabase();

            String whereClause = key + "=?";

            String[] whereArgs = {value};
            int result = db.update(getTableName(obj.getClass()), values, whereClause, whereArgs);
          ///  Log.i(TAG, "update ok? " + result);

        } catch (Exception e) {
            Log.e(TAG, "updateByKey is error: " + e.getMessage());
        }

    }

    //    @Override
//    public <T> void updateByKey(Object obj, String key, String value) {
//        createTableIfNotExists(obj.getClass());
//        String tableName=getTableName(obj.getClass());
//        SQLiteDatabase db = getWritableDatabase();
//
////        List<JSONObject> list = queryByKey(obj.getClass(), key, value);
////        if (list == null) {
////            save(obj);
////            return;
////        }
////        if (list.size() == 0) {
////            save(obj);
////            return;
////        }
//        Log.i(TAG, "update start");
//        /**
//         * UPDATE table_name
//         SET column1 = value1, column2 = value2...., columnN = valueN
//         WHERE [condition];
//         */
//        try {
//            JSONObject jsonObject = FastJsonUtils.toJsonObject(obj);
//            Set<String> keys = jsonObject.keySet();
//            //   for (JSONObject j : list) {
//            StringBuilder sb = new StringBuilder();
//            sb.append("update ");
//            sb.append(tableName);
//            sb.append(" set ");
//            ContentValues values = new ContentValues();
//            for (String s : keys) {
//                if (jsonObject.get(s) != null) {
//                    if (!jsonObject.get(s).toString().equals("-1")) {
//                        String v = jsonObject.get(s).toString();//.replace(".", "_");
//                        // v = v.replace(":", "_");
//                        sb.append(s + " = '" + v + "',");
//                        values.put(s, v);
//                    }
//                }
//            }
//            String str = sb.substring(0, sb.length() - 1);
//            sb = new StringBuilder();
//            sb.append(str);
//
//            sb.append(" where ");
//            sb.append(key);
//            sb.append(" = '" + value + "' ");
//
//
//            Log.i(TAG, sb.toString());
//            db.execSQL(sb.toString());
//
//            Log.i(TAG, "update ok " );
//            //  }
//        } catch (Exception e) {
//            Log.e(TAG, "updateByKey is error: " + e.getMessage());
//        }
//
//    }
//    @Override
//    public <T> void updateByKey(Object obj, String key, String value) {
//        createTableIfNotExists(obj.getClass());
//        String tableName = getTableName(obj.getClass());
//        SQLiteDatabase db = getWritableDatabase();
//
//        Log.i(TAG, "update start");
//        /**
//         * UPDATE table_name
//         SET column1 = value1, column2 = value2...., columnN = valueN
//         WHERE [condition];
//         */
//        try {
//            JSONObject jsonObject = FastJsonUtils.toJsonObject(obj);
//            Set<String> keys = jsonObject.keySet();
//            //   for (JSONObject j : list) {
//            StringBuilder sb = new StringBuilder();
//            sb.append("update ");
//            sb.append(tableName);
//            sb.append(" set ");
//            ContentValues values = new ContentValues();
//            for (String s : keys) {
//                if (jsonObject.get(s) != null) {
//                    if (!jsonObject.get(s).toString().equals("-1")) {
//                        String v = jsonObject.get(s).toString();//.replace(".", "_");
//                        // v = v.replace(":", "_");
//                        sb.append(s + " = '" + v + "',");
//                        values.put(s, v);
//                    }
//                }
//            }
//            String str = sb.substring(0, sb.length() - 1);
//            sb = new StringBuilder();
//            sb.append(str);
//
//            sb.append(" where ");
//            sb.append(key);
//            sb.append(" = '" + value + "' ");
//
//
//            Log.i(TAG, sb.toString());
//            db.execSQL(sb.toString());
//
//            Log.i(TAG, "update ok ");
//            //  }
//        } catch (Exception e) {
//            Log.e(TAG, "updateByKey is error: " + e.getMessage());
//        }
//
//    }


    /**
     * 通过表名清空所有的数据
     *
     * @param table 类类型
     */
    @Override
    public void clear(Class table) {
        try {
            SQLiteDatabase db = getWritableDatabase();
            String tableName = getTableName(table);
            db.delete(tableName, null, null);
        } catch (Exception e) {

        }
    }

    @Override
    public void deleteByKey(Class table, String key, String value) {

        SQLiteDatabase db = getWritableDatabase();
        try {
            String tableName = getTableName(table);
            db.delete(tableName,
                    key + " = ?",
                    new String[]{value});
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 删除数据
     *
     * @param obj 指定对象（表）中的数据
     */
    @Override
    public void delete(Object obj) {
        SQLiteDatabase db = getWritableDatabase();
        // Log.i(TAG, "delete: " + FastJsonUtils.toJSONString(obj));
        delete(obj, db);
    }

    @Override
    public void deleteTable(Object obj) {
        String str = "drop table " + getTableName(obj.getClass());
        Log.i(TAG, str);
        SQLiteDatabase db = getWritableDatabase();
        db.execSQL(str);
    }

    /**
     * 主要删除操作，主要是通过id来删除，因为删除一条操作必须有一个唯一列项
     *
     * @param obj 指定对象（表）中的数据
     * @param db
     */
    private void delete(Object obj, SQLiteDatabase db) {
        //首先获取该类中的id，如果有就会获取到

        Field idField = getFieldId(obj.getClass());
        //如果不存在属性id，就不需要删除
        if (idField != null) {
            idField.setAccessible(true);
            try {
                String tableName = getTableName(obj.getClass());
                // Log.i(TAG, "id: " + idField.getName());

                db.delete(tableName,
                        idField.getName() + " = ?",
                        new String[]{idField.get(obj).toString()});
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 删除集合中所有的对象数据
     *
     * @param collection
     */
    @Override
    public void deleteAll(Collection collection) {
        SQLiteDatabase db = getWritableDatabase();
        db.beginTransaction();
        for (Object o : collection) {
            delete(o, db);
        }
        db.setTransactionSuccessful();
        db.endTransaction();
    }

    @Override
    public <T> void test(Class<T> table, String key, String value) {

    }


    private <T> int getQueryCount(Class<T> table, String key, String value) {
        SQLiteDatabase db = getWritableDatabase();
        StringBuilder sb = new StringBuilder();
        sb.append("select * from ");
        sb.append(getTableName(table));
        sb.append(" where ");
        sb.append(key);
        sb.append(" = '");
        sb.append(value);
        sb.append("'");
       // Log.i(TAG, sb.toString());
        Cursor cursor = db.rawQuery(sb.toString(), null);
      //  Log.i(TAG, cursor.getColumnCount() + "-->" + cursor.getCount());
        return cursor.getCount();
    }

    private <T> T initEntity(Class<T> table, Cursor cursor) {
        List<T> list = initList(table, cursor);
        if (list != null) {
            return list.get(0);
        }
        return null;
    }

    /**
     * 这个方法的主要功能是将数据中查询到的数据放到集合中。
     * 类似于我们查询到对应的数据重新封装到一个对象中，然后把这个对象
     * 放入集合中。这样就能拿到我们的数据集了
     *
     * @param table
     * @param cursor
     * @param <T>
     * @return
     */
    private <T> List<T> initList(Class<T> table, Cursor cursor) {
        List<T> result = new ArrayList<T>();
        //这里可能大家不了解，这是Gson为我们提供的一个通过JDK内部API 来创建对象实例，这里不做过多讲解
        UnsafeAllocator allocator = UnsafeAllocator.create();
        while (cursor.moveToNext()) {
            try {
                //创建具体的实例
                T t = allocator.newInstance(table);
                if (table.getSuperclass() != null) {

                }
                boolean flag = true;

                //遍历所有的游标数据
                for (int i = 0; i < cursor.getColumnCount(); i++) {

                    //每次都去查找该类中有没有自带的id，如果没有，就不应该执行下面的语句
                    //因为下面获取属性名时，有一个异常抛出，要是找不到属性就会结束这个for循环
                    //后面的所有数据就拿不到了,只要检测到没有id，就不需要再检测了。
                    if (flag) {
                        Field fieldId = getFieldId(table);
                        if (fieldId == null) {
                            flag = !flag;
                            continue;
                        }
                    }
                    //通过列名获取对象中对应的属性名

                    if (isFieldExists(table, cursor.getColumnName(i))) {
                        Field field = table.getField(cursor.getColumnName(i));
                        //获取属性的类型
                        Class<?> type = field.getType();
                        //设置属性的访问权限为最高权限，因为要设置对应的数据
                        field.setAccessible(true);
                        //获取到数据库中的值，由于sqlite是采用若语法，都可以使用getString来获取
                        String value = cursor.getString(i);

                        //通过判断类型，保存到指定类型的属性中，这里判断了我们常用的数据类型。
                        if (type.equals(Byte.class) || type.equals(Byte.TYPE)) {
                            field.set(t, Byte.parseByte(value));
                        } else if (type.equals(Short.class) || type.equals(Short.TYPE)) {
                            field.set(t, Short.parseShort(value));
                        } else if (type.equals(Integer.class) || type.equals(Integer.TYPE)) {
                            field.set(t, Integer.parseInt(value));
                        } else if (type.equals(Long.class) || type.equals(Long.TYPE)) {
                            field.set(t, Long.parseLong(value));
                        } else if (type.equals(Float.class) || type.equals(Float.TYPE)) {
                            field.set(t, Float.parseFloat(value));
                        } else if (type.equals(Double.class) || type.equals(Double.TYPE)) {
                            field.set(t, Double.parseDouble(value));
                        } else if (type.equals(Character.class) || type.equals(Character.TYPE)) {
                            field.set(t, value.charAt(0));
                        } else if (type.equals(Boolean.class) || type.equals(Boolean.TYPE)) {
                            field.set(t, Boolean.parseBoolean(value));
                        } else if (type.equals(String.class)) {
                            field.set(t, value);
                        } else if (type.equals(JSONObject.class)) {
                            field.set(t, FastJsonUtils.toJsonObject(value));
                        } else if (type.equals(JSONArray.class)) {
                            field.set(t, FastJsonUtils.toJSONArray(value));
                        }
                    }
                }
                result.add(t);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return result;
    }


    private <T> List<JSONObject> getJson(Class<T> table, Cursor cursor) {

        UnsafeAllocator allocator = UnsafeAllocator.create();
        //     Log.i(TAG,"cursor.moveToNext(): "+cursor.moveToNext());
        List<JSONObject> list = new ArrayList<>();
        while (cursor.moveToNext()) {
            try {
                JSONObject json = new JSONObject();
                //创建具体的实例
                T t = allocator.newInstance(table);
                if (table.getSuperclass() != null) {

                }
                boolean flag = true;
                Log.i(TAG, "cursor.getColumnCount(): " + cursor.getColumnCount());
                //遍历所有的游标数据

                for (int i = 0; i < cursor.getColumnCount(); i++) {

                    //每次都去查找该类中有没有自带的id，如果没有，就不应该执行下面的语句
                    //因为下面获取属性名时，有一个异常抛出，要是找不到属性就会结束这个for循环
                    //后面的所有数据就拿不到了,只要检测到没有id，就不需要再检测了。
                    if (flag) {
                        Field fieldId = getFieldId(table);
                        if (fieldId == null) {
                            flag = !flag;
                            continue;
                        }
                    }
                    //通过列名获取对象中对应的属性名

                    if (isFieldExists(table, cursor.getColumnName(i))) {
                        Field field = table.getField(cursor.getColumnName(i));
                        //获取属性的类型
                        Class<?> type = field.getType();
                        //设置属性的访问权限为最高权限，因为要设置对应的数据
                        field.setAccessible(true);
                        //获取到数据库中的值，由于sqlite是采用若语法，都可以使用getString来获取
                        String value = cursor.getString(i);
                        Log.i(TAG, cursor.getColumnName(i) + " value: " + value);
                        String key = cursor.getColumnName(i);
                        //通过判断类型，保存到指定类型的属性中，这里判断了我们常用的数据类型。
                        if (type.equals(Byte.class) || type.equals(Byte.TYPE)) {
                            field.set(t, ConverterUtils.str2byte(value, "0".getBytes()[0]));
                            json.put(key, Byte.parseByte(value));
                        } else if (type.equals(Short.class) || type.equals(Short.TYPE)) {
                            field.set(t, Short.parseShort(value));
                            json.put(key, ConverterUtils.str2short(value, (short) 0));
                        } else if (type.equals(Integer.class) || type.equals(Integer.TYPE)) {
                            field.set(t, Integer.parseInt(value));
                            json.put(key, ConverterUtils.str2int(value, -1));
                        } else if (type.equals(Long.class) || type.equals(Long.TYPE)) {
                            field.set(t, Long.parseLong(value));
                            json.put(key, ConverterUtils.str2long(value, -1));
                        } else if (type.equals(Float.class) || type.equals(Float.TYPE)) {
                            field.set(t, Float.parseFloat(value));
                            json.put(key, ConverterUtils.str2float(value, -1));
                        } else if (type.equals(Double.class) || type.equals(Double.TYPE)) {
                            field.set(t, Double.parseDouble(value));
                            json.put(key, ConverterUtils.str2double(value, -1));
                        } else if (type.equals(Character.class) || type.equals(Character.TYPE)) {
                            field.set(t, value.charAt(0));
                            json.put(key, value.charAt(0));
                        } else if (type.equals(Boolean.class) || type.equals(Boolean.TYPE)) {
                            field.set(t, Boolean.parseBoolean(value));
                            json.put(key, ConverterUtils.str2boolean(value, false));
                        } else if (type.equals(String.class)) {
                            field.set(t, value);
                            json.put(key, value);
                        } else if (type.equals(JSONObject.class)) {
                            field.set(t, FastJsonUtils.toJsonObject(value));
                            json.put(key, FastJsonUtils.toJsonObject(value));
                        } else if (type.equals(JSONArray.class)) {
                            field.set(t, FastJsonUtils.toJSONArray(value));
                            json.put(key, FastJsonUtils.toJSONArray(value));
                        }
                    }
                }
                list.add(json);
            } catch (Exception e) {
                Log.e(TAG, "get value error: " + e.getMessage());
                e.printStackTrace();
                // return null;
            }

        }
        return list;
    }

    private boolean isFieldExists(Class table, String fieldName) {
        for (Field f : table.getFields()) {
            if (f.getName().equals(fieldName)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断表格是否存在
     *
     * @param table
     * @return
     */
    private boolean isTableExists(Class table) {
        // return  true;
        boolean isExists = false;
        try {
            SQLiteDatabase db = getReadableDatabase();
            //查询表是否存在
            String tableName = getTableName(table);

            Cursor cursor = db.query("sqlite_master", null, "type = 'table' and name = ?", new String[]{tableName}, null, null, null);

            isExists = cursor.getCount() > 0;
           // Log.i(TAG, "table: " + tableName + " is exist? " + isExists);
            cursor.close();

        } catch (Exception e) {
            Log.e(TAG, "isTableExists error " + e.getMessage());
        }

        return isExists;
    }

    /**
     * 如果表格不存在就创建该表。如果存在就不创建
     *
     * @param table
     */
    private void createTableIfNotExists(Class table) {
        if (!isTableExists(table)) {
            try {
                String tableName = getTableName(table);
                Log.i(TAG, "create table: " + tableName);
                SQLiteDatabase db = getWritableDatabase();
                StringBuilder builder = new StringBuilder();
                builder.append("CREATE TABLE IF NOT EXISTS ");
                builder.append(tableName);
                builder.append(" ( ");
                Field id = getFieldId(table);
                if (id == null) {
                    builder.append("_id Integer PRIMARY KEY AUTOINCREMENT,");
                } else {
                    builder.append(id.getName()).append(" Integer PRIMARY KEY AUTOINCREMENT, ");
                }
                for (Field field : table.getFields()) {
                    int modifiers = field.getModifiers();
                    //  Log.i(TAG, "field: " + field.getName());
                    if (!field.equals(id) && !Modifier.isStatic(modifiers)) {
                        //   Log.i(TAG, "append: " + field.getName());
                        builder.append(field.getName()).append(",");
                    }
                }

                builder.deleteCharAt(builder.length() - 1);
                builder.append(" )");
                Log.i(TAG, "cmd: " + builder.toString());
                db.execSQL(builder.toString());
                Log.i(TAG, "create table ok: " + tableName);
            } catch (Exception e) {
                Log.e(TAG, "create table error: " + e.getMessage());
            }

        } else {
            // Log.i(TAG, "TABLE IS EX");
        }
    }

    /**
     * 获取对象属性中的id字段，如果有就获取，没有就不获取
     *
     * @param table
     * @return
     */
    private Field getFieldId(Class table) {
        Field fieldId = null;
        try {
            fieldId = table.getField("id");
            if (fieldId == null) {
                table.getField("_id");
            }
        } catch (NoSuchFieldException e) {
            //  e.printStackTrace();
            // Log.w(TAG, "getFieldId fail");
        }
        return fieldId;
    }
    private Field getFieldId(Class table,String id) {
        Field fieldId = null;
        try {
            fieldId = table.getField(id);
            if (fieldId == null) {
                table.getField("_id");
            }
        } catch (NoSuchFieldException e) {
            //  e.printStackTrace();
            // Log.w(TAG, "getFieldId fail");
        }
        return fieldId;
    }
    public <T> String getTableName(Class<T> obj) {

        // Log.i(TAG, "Table name: " + obj.getSimpleName());
        return obj.getSimpleName();
    }
}
